package com.atguigu.java;

import org.junit.Test;

import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author : leimingchao
 * @Description:
 * @date Date : 2021年06月13日 9:51
 */
public class ReflectionTest {
    /**
     * 反射之前，对于Person的操作
     */
    @Test
    public void test() {
        //1.创建Person类的对象
        Person person = new Person("Tom", 12);
        person.age = 10;
        System.out.println(person.toString());
        person.show();

        //在Person类外部，不可以通过Person类的对象调用其内部的私有结构
        //name,showNation,以及私有的构造器
    }

    /**
     * 反射之后，对于Person的操作
     */
    @Test
    public void test2() throws Exception {
        Class clazz = Person.class;
        //1.通过反射创建Person类对象
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object obj = constructor.newInstance("Tom", 12);
        Person person = (Person) obj;
        System.out.println(person.toString());
        //2.通过反射，调用对象指定的属性和方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(person, 10);
        System.out.println(person.toString());
        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(person);
        System.out.println("==============================================");
        //通过反射，可以调用Person类的私有结构的，比如：私有的构造器，方法，属性
        //调用私有的构造器
        Constructor constructor1 = clazz.getDeclaredConstructor(String.class);
        constructor1.setAccessible(true);
        Object obj1 = constructor1.newInstance("Jerry");
        Person person2 = (Person) obj1;
        System.out.println(person2);

        //调用私有属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(person2, "HanMeiMei");
        System.out.println(person2);

        //调用私有方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        //相当于 String nation = person2.showNation("中国")
        String nation = (String) showNation.invoke(person2, "中国");
        System.out.println(nation);
    }

    /**
     * 疑问：通过直接new的方式或者反射的方式都可以调用公共的结构，开发中到底用哪个？
     *       建议：直接new的方式
     *       什么时候会使用：反射的方式，反射的特征：动态性
     *
     * 疑问：反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
     *       不矛盾，
     */

    /**
     * 关于java.lang.Class的理解
     *     1.类的加载过程：
     *         程序在经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)，接着我们使用java.exe命令对某个字节码文件
     *         进行解释运行。相当于将某个字节码文件加载到内存中，此过程就成为类的加载。加载到内存中的类，我们就称为运行时类，此
     *         运行时类，就作为Class的一个实例
     *     2.换句话说：Class的实例就对应一个运行时类
     *     3.加载到内存中的运行时类，会缓存一段时间，在此时间内，我们可以通过不同的方式来获取此运行时类
     */

    /**
     * 万事万物皆对象？
     */

    /**
     * 获取Class的实例方式（前3种方式需要掌握）
     */
    @Test
    public void test3() throws ClassNotFoundException {
        //方式一：调用运行时类的属性：.class
        Class clazz = Person.class;
        System.out.println(clazz);
        //方式二：通过运行时类的对象,调用getClass()
        // Person person = new Person();
        // Class clazz2 = person.getClass();
        // System.out.println(clazz2);
        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("com.atguigu.java.Person");
        System.out.println(clazz3);
        // System.out.println(clazz == clazz2);
        System.out.println(clazz == clazz3);
        //方式四：使用类的加载器：ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz5 = ClassLoader.getSystemClassLoader().loadClass("com.atguigu.java.Person");
        Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");
        System.out.println(clazz4 == clazz);
        System.out.println(clazz5 == clazz);

    }

    /**
     * Class实例可以是哪些结构的说明：
     */
    @Test
    public void test4() {
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = ElementType.class;
        Class c6 = Override.class;
        Class c7 = int.class;
        Class c8 = void.class;
        Class c9 = Class.class;
        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        // 只要数组的元素类型与维度一样，就是同一Class
        System.out.println(c10 == c11);
    }
}
